const express = require('express');
const router = express.Router();
const fs = require('fs');

const util = require('../util');
const classifier = require('../classifier');

/**
 * api请求接口路由，接收rest api报文：
 * {
 *    method: get|post|json|other plus,     //发送到光闸另一端请求的发送插件
 *    request_url: url...,                  //发送到光闸另一端请求的url
 *    request_header: {},                   //请求的http header，json格式，可空
 *    request_content: {},                  //请求的body，当插件为get|post时，不支持嵌套格式，可空
 *    request_timeout: 20000,                //光闸另一端请求的超时时间，默认20000ms
 *    back_url: url...                     //请求完成后的回调地址，用于通知发起请求的系统
 * }
 * 
 * api请求的响应报文：{header: {code, message}, sequence, stack}，无其它响应内容
 * 此处的响应只表示 ligit-gateway 收到请求，并成功写入了光闸数据交换目录，不表示该次请求对应的响应报文。
 */

const logger = util.logger;
const REQUEST_TIMEOUT = 20000;      //默认的超时时间
const LIGHT_SWAP_TIME = 10000;      //默认光闸交换数据时间

/* GET users listing. */
router.get('/', function(req, res, next) {
  logger.debug('sss....');
  res.send('respond with a resource');
});

/**
 * 接收 request 请求
 */
router.post('/request', (req, res, next) =>{
  logger.debug('接收到请求 body:', req.body);
  let reqJson = req.body;
  let checkResult = checkRequest(reqJson);
  if (checkResult){
    logger.warn('请求校验错误：', checkResult);
    res.json({
      header: checkResult
    });
    return;
  }
  //生成请求文件
  let sequence = util.pushRequest(reqJson);
  logger.debug('写入请求缓存成功');
  res.json({
    header: util.sucResMsg,
    sequence
  });
});

/**
 * 接收 request 请求，并同步返回响应数据
 */
router.post('/request-sync', (req, res, next) =>{
  logger.debug('接收到同步请求 body:', req.body);
  let reqJson = req.body;
  let checkResult = checkRequest(reqJson, true);
  if (checkResult){
    logger.warn('请求校验错误：', checkResult);
    res.json({
      header: checkResult
    });
    return;
  }

  //同步请求需删除 back_url
  if (reqJson.back_url){
    reqJson.back_url = undefined;
  }

  //生成请求文件
  let sequence = util.pushRequest(reqJson);
  logger.debug('写入请求缓存成功');

  let timer = setTimeout(() => {
    logger.warn(`同步请求 ${sequence} 超时`);
    util.emitNotice(sequence, {
      header: util.getErrMsg('request_timeout')
    });
  }, reqJson.request_timeout + LIGHT_SWAP_TIME);    //超时时间为： request_timeout + 光闸数据交换时间

  //绑定通知事件
  util.bindNotice(sequence, (json) => {
    clearTimeout(timer);    //清除超时定时器
    res.json(json);
  });

});

/**
 * 检查请求报文，返回的错误信息可以直接做为response
 */
function checkRequest(json, noBackUrl){
  if (!json.method){
    return util.getErrMsg('method_not_null');   //method不能为空
  }
  if (!json.request_url){
    return util.getErrMsg('request_url_not_null');  //request_url不能为空
  }
  if (!noBackUrl && !json.back_url){
    return util.getErrMsg('back_url_not_null');   //back_url不能为空
  }

  //增加超时时间
  if (!json.request_timeout){
    json.request_timeout = REQUEST_TIMEOUT;
  }

  //检查method对应的插件是否存在
  json.method = json.method.toLowerCase();
  //在请求报文中的method参数，用于指定光闸另一侧程序转发请求的方式，但是放在此处进行校验
  //由于光闸两侧部署的程序是一样的，所以可以在此处校验
  return classifier.checkForwardMethod(json.method);
}

module.exports = router;
